phase 0: scaffold + layer guard + ci wiring - #326

#!/bin/bash
# Expect current output to report `/services/` as the deciding ignore rule.
# After the fix, `/services/.gitkeep` should no longer be ignored.
git check-ignore --no-index -v services/.gitkeep || true

# This should still be ignored by `/services/*`.
git check-ignore --no-index -v services/scratch.txt || true

# First, let's read the full check_layer_imports.py file to understand LAYERS and the function's context
cat -n scripts/check_layer_imports.py

# Look for what module formats are actually passed to layer_of() - check callers
rg -A 5 "layer_of\(" scripts/check_layer_imports.py

# Search for actual imports in the codebase to see the format used
rg "^from (services|api|components|core|di)\." openrag/ -m 5

# Search for imports from the four layers (core, services, api, di) in files under those directories
rg "^from (core|services|api|di)\." openrag/

# Check if any files exist in these layer directories
find openrag -maxdepth 2 -type d -name "core" -o -name "services" -o -name "api" -o -name "di"

# Also check if there are any imports starting with openrag. in the layer directories
rg "^from openrag\." openrag/core openrag/services openrag/api openrag/di 2>/dev/null || echo "Likely no such files yet"

# Check what files actually exist in these refactoring layer directories
find openrag/core openrag/services openrag/api openrag/di -type f -name "*.py" 2>/dev/null

# Let's also check the documentation or comments about the refactoring to understand the intent
cat openrag/api/.gitkeep openrag/core/.gitkeep openrag/services/.gitkeep openrag/di/.gitkeep 2>/dev/null || echo "No .gitkeep files"

# Check if there's any migration guidance in the main CLAUDE.md or README
grep -i "refactor\|layer\|migration" CLAUDE.md README.md 2>/dev/null | head -20

# Let's look at actual imports in some of the new refactoring layer files to see what format they use
head -50 openrag/core/__init__.py

# Check a service file
head -50 openrag/services/__init__.py

# Check an API file
head -50 openrag/api/__init__.py

# Look at actual imports in a deeper file
rg "^from\s+(core|services|api|di|openrag)\." openrag/core/ openrag/services/ openrag/api/ openrag/di/ -m 10

# Check file sizes to see if they're empty or have content
wc -l openrag/core/__init__.py openrag/services/__init__.py openrag/api/__init__.py openrag/di/__init__.py

# Check a non-empty file deeper in the hierarchy
wc -l openrag/core/models/__init__.py openrag/services/auth/__init__.py openrag/api/routers/__init__.py

# Get actual content from a few of these files
cat openrag/core/models/__init__.py

# Check a file that likely has imports
cat openrag/services/auth/__init__.py

# Check api routers
head -30 openrag/api/routers/__init__.py

# Find non-empty .py files in the refactoring layer directories
find openrag/core openrag/services openrag/api openrag/di -type f -name "*.py" -size +0 2>/dev/null

# Check if there's any content at all in these directories
find openrag/core openrag/services openrag/api openrag/di -type f ! -name "__init__.py" 2>/dev/null | head -20

# List all files in the refactoring layer directories
find openrag/core openrag/services openrag/api openrag/di -type f 2>/dev/null

# Let's verify the intent by checking if there are test files that might import from these layers
find openrag -name "test_*.py" -o -name "*_test.py" | xargs grep -l "from (core|services|api|di)\." 2>/dev/null | head -5

# Check the git history or any TODO comments about the refactoring
rg "TODO|FIXME|refactor" scripts/check_layer_imports.py

# Understand the context better: when the check script runs, what would be the format of modules?
# Let's trace through an example: if openrag/api/routers/foo.py has "from services.bar import X"
# What would iter_imports yield and what would be passed to layer_of()?
python3 << 'EOF'
import ast

# Simulate what happens with a top-level import
code = "from services.bar import X"
tree = ast.parse(code)
for node in ast.walk(tree):
    if isinstance(node, ast.ImportFrom):
        print(f"ImportFrom found: module={node.module}, level={node.level}")
        # When level=0 (absolute), node.module is passed to layer_of()
        print(f"Would pass to layer_of(): {node.module}")
EOF

# Also check what the current layer_of would return for this
python3 << 'EOF'
def layer_of(module: str) -> str | None:
    """Current implementation"""
    LAYERS = ("core", "services", "api", "di")
    parts = module.split(".")
    if len(parts) >= 2 and parts[0] == "openrag" and parts[1] in LAYERS:
        return parts[1]
    return None

# Test cases
test_cases = [
    "services.bar",           # Top-level layer import (from learning)
    "openrag.services.bar",   # openrag-prefixed import
    "components.foo",         # Legacy import
    "core.models.User",       # Top-level core import
]

for test in test_cases:
    result = layer_of(test)
    print(f"layer_of('{test}') = {result}")
EOF

cat -n scripts/check_layer_imports.py | head -100

cat -n scripts/check_layer_imports.py | sed -n '100,120p'